/**
 * 将两个数组合并转为数组对象,key为动态
 * @param { arr[] } arr1 arr1 - 要合并的数组 如 arr1=['1月','2月','3月']
 * @param { arr[] } arr2 arr2 - 要合并的数组 如 arr2=[1,2,3]
 * @param { string } key1 - 键名 如 'label'
 * @param { string } key2 - 键名 如 'value'
 * @returns { Object[] } 合并后的对象数组 如 [{label:'1月',value:1},{label:'2月',value:2}]
 * @call changeArrayObj2(arr1,arr2,'label','value')
*/
export const changeArrayObj2 = (arr1, arr2, key1, key2) => {
  let arr = [], obj = {};
  arr1.forEach((item, index) => {
    obj[key1] = item;
    obj[key2] = arr2[index];
    arr.push(obj);
  });
  return arr;
}

/**
 * 将数组转为数组对象,key为动态
 * @param { arr[] } arr - 要合并的数组 如 arr=[1,2,3]
 * @param { string } key - 键名 如 'label'
 * @returns { Object[] } 合并后的对象数组 如 [{label:'1'},{label:'2'}]
 * @call changeArrayObj1(arr,'label')
*/
export const changeArrayObj1 = (arr, key) => {
  return arr.map(item => {
    let obj = {};
    obj[key] = item;
    return obj;
  });
  // 例如：arr1 = ['1月','2月','3月','4月']; 想得到arr = [{label:'1月'},{label:'2月'}]
  // changeArrayObj(arr1,'label');
}

/**
 * 将多个数组合并成对象数组（动态键名）
 * @param { string[] } keys - 键名数组，如 keys=['id', 'name', 'age']
 * @param { ...any[] } arrays - 要合并的数组，如 ids=[1,2,3], names=['lily','tom','jok'], ages=[18,20,30]
 * @returns { Object[] } 合并后的对象数组 如 [{id:1,name:'lily',age:18},{id:2,name:'tom',age:20}]
 * @call arraysToObjects(keys,ids,names,ages)
 */
export const arraysToObjects = (keys, ...arrays) => {
  // 检查输入是否合法
  if (!keys || !arrays || arrays.length === 0) {
    throw new Error("必须提供 keys 和至少一个数组");
  }
  if (keys.length !== arrays.length) {
    throw new Error("keys 的数量必须和数组数量一致");
  }
  // 获取最短数组的长度（避免越界）
  const minLength = Math.min(...arrays.map(arr => arr.length));
  // 遍历并合并
  return Array.from({ length: minLength }, (_, index) => {
    const obj = {};
    keys.forEach((key, i) => {
      obj[key] = arrays[i][index];
    });
    return obj;
  });
}

/**
 * 将多个数组合并成对象数组（动态键名）处理空数组、不等长数组等 【优化版本（更健壮）】
 * @param { string[] } keys - 键名数组，如 keys=['id', 'name', 'age']
 * @param { ...any[] } arrays - 要合并的数组，如 ids=[1,2,3], names=['lily','tom','jok'], ages=[18,20,30]
 * @returns { Object[] } 合并后的对象数组 如 [{id:1,name:'lily',age:18},{id:2,name:'tom',age:20}]
 * @call arraysToObjects(keys,ids,names,ages)
 */
export const combineArraysToObjects = (keys, ...arrays) => {
  // ?.是可选链接操作符；作用是安全地访问嵌套属性，避免 undefined 或 null 导致的报错。

  // 检查数组是否为空或未定义：即keys或arrays是否等于null,undefined,或者length=0
  if (!keys?.length || !arrays?.length) {
    // 如果keys或arrays是否等于null,undefined,或者length=0，则返回空数组
    return [];
  }

  // 计算多个数组中最短的那个数组的长度，当出现null,undefined时会赋值为0
  const minLength = Math.min(...arrays.map(arr => arr?.length || 0));

  // 如果最小长度为0，则返回空数组
  if (minLength === 0) {
    return [];
  }

  // 创建并返回一个长度为minLength的新数组  (_, index) => {...}:回调函数，index 是当前项的索引（_ 表示未使用的参数）
  return Array.from({ length: minLength }, (_, index) => {
    // keys.reduce((obj, key, i) => { ... }, {})：遍历 keys 数组，动态构建对象 obj
    // obj：初始为空对象 {}，每次迭代添加一个新属性。
    // key：当前键名（如 'id'、'name'）。
    // i：当前 key 的索引，用于从 arrays[i] 获取对应的数组。
    return keys.reduce((obj, key, i) => {
      // arrays[i]?.[index]：安全访问 arrays[i] 的第 index 个元素（如果 arrays[i] 不存在或越界，返回 undefined）
      // ?? null：如果左侧是 undefined 或 null，则默认赋值为 null（避免对象中出现 undefined）
      obj[key] = arrays[i]?.[index] ?? null;
      return obj;
    }, {});
  });
}